// RAP [rh] ICommandManager and related classes disabled
///*******************************************************************************
// * Copyright (c) 2004, 2006 IBM Corporation and others.
// * All rights reserved. This program and the accompanying materials
// * are made available under the terms of the Eclipse Public License v1.0
// * which accompanies this distribution, and is available at
// * http://www.eclipse.org/legal/epl-v10.html
// *
// * Contributors:
// * IBM Corporation - initial API and implementation
// *******************************************************************************/
//package org.eclipse.ui.internal.commands;
//
//import java.util.ArrayList;
//import java.util.HashMap;
//import java.util.HashSet;
//import java.util.Iterator;
//import java.util.List;
//import java.util.Map;
//import java.util.Set;
//
//import org.eclipse.core.commands.Command;
//import org.eclipse.core.commands.CommandManager;
//import org.eclipse.core.commands.contexts.ContextManager;
//import org.eclipse.core.commands.contexts.ContextManagerEvent;
//import org.eclipse.core.commands.contexts.IContextManagerListener;
//import org.eclipse.jface.bindings.BindingManager;
//import org.eclipse.jface.bindings.BindingManagerEvent;
//import org.eclipse.jface.bindings.IBindingManagerListener;
//import org.eclipse.jface.bindings.Scheme;
//import org.eclipse.ui.commands.CommandManagerEvent;
//import org.eclipse.ui.commands.ICategory;
//import org.eclipse.ui.commands.ICommand;
//import org.eclipse.ui.commands.ICommandManager;
//import org.eclipse.ui.commands.ICommandManagerListener;
//import org.eclipse.ui.commands.IKeyConfiguration;
//import org.eclipse.ui.internal.handlers.LegacyHandlerWrapper;
//import org.eclipse.ui.internal.keys.SchemeLegacyWrapper;
//import org.eclipse.ui.internal.util.Util;
//import org.eclipse.ui.keys.KeySequence;
//
///**
// * Provides support for the old <code>ICommandManager</code> interface.
// */
//public final class CommandManagerLegacyWrapper implements ICommandManager,
// org.eclipse.core.commands.ICommandManagerListener,
// IBindingManagerListener, IContextManagerListener {
//
// /**
// * Whether commands should print out information about which handlers are
// * being executed. Change this value if you want console output on command
// * execution.
// */
// public static boolean DEBUG_COMMAND_EXECUTION = false;
//
// /**
// * Whether commands should print out information about handler changes.
// * Change this value if you want console output when commands change
// * handlers.
// */
// public static boolean DEBUG_HANDLERS = false;
//
// /**
// * Which command should print out debugging information. Change this value
// * if you want to only here when a command with a particular identifier
// * changes its handler.
// */
// public static String DEBUG_HANDLERS_COMMAND_ID = null;
//
// static boolean validateKeySequence(KeySequence keySequence) {
// if (keySequence == null) {
// return false;
// }
// List keyStrokes = keySequence.getKeyStrokes();
// int size = keyStrokes.size();
// if (size == 0 || size > 4 || !keySequence.isComplete()) {
// return false;
// }
// return true;
// }
//
// /**
// * The JFace binding machine that provides binding support for this
// * workbench mutable command manager. This value will never be
// * <code>null</code>.
// */
// private final BindingManager bindingManager;
//
// /**
// * The command manager that provides functionality for this workbench
// * command manager. This value will never be <code>null</code>.
// */
// private final CommandManager commandManager;
//
// private List commandManagerListeners;
//
// /**
// * The context manager that provides functionality for this workbench
// * command manager. This value will never be <code>null</code>.
// */
// private final ContextManager contextManager;
//
// /**
// * Constructs a new instance of <code>MutableCommandManager</code>. The
// * binding manager and command manager providing support for this manager
// * are constructed at this time.
// *
// * @param bindingManager
// * The binding manager providing support for the command manager;
// * must not be <code>null</code>.
// * @param commandManager
// * The command manager providing support for this command
// * manager; must not be <code>null</code>.
// * @param contextManager
// * The context manager to provide context support to this
// * manager. This value must not be <code>null</code>.
// *
// */
// public CommandManagerLegacyWrapper(final BindingManager bindingManager,
// final CommandManager commandManager,
// final ContextManager contextManager) {
// if (contextManager == null) {
// throw new NullPointerException(
// "The context manager cannot be null."); //$NON-NLS-1$
// }
// this.bindingManager = bindingManager;
// this.commandManager = commandManager;
// this.contextManager = contextManager;
// }
//
// public final void addCommandManagerListener(
// final ICommandManagerListener commandManagerListener) {
// if (commandManagerListener == null) {
// throw new NullPointerException("Cannot add a null listener."); //$NON-NLS-1$
// }
//
// if (commandManagerListeners == null) {
// commandManagerListeners = new ArrayList();
// this.commandManager.addCommandManagerListener(this);
// this.bindingManager.addBindingManagerListener(this);
// this.contextManager.addContextManagerListener(this);
// }
//
// if (!commandManagerListeners.contains(commandManagerListener)) {
// commandManagerListeners.add(commandManagerListener);
// }
// }
//
// /*
// * (non-Javadoc)
// *
// * @see org.eclipse.jface.bindings.IBindingManagerListener#bindingManagerChanged(org.eclipse.jface.bindings.BindingManagerEvent)
// */
// public final void bindingManagerChanged(final BindingManagerEvent event) {
// final boolean schemeDefinitionsChanged = event.getScheme() != null;
// final Set previousSchemes;
// if (schemeDefinitionsChanged) {
// previousSchemes = new HashSet();
// final Scheme scheme = event.getScheme();
// final Scheme[] definedSchemes = event.getManager()
// .getDefinedSchemes();
// final int definedSchemesCount = definedSchemes.length;
// for (int i = 0; i < definedSchemesCount; i++) {
// final Scheme definedScheme = definedSchemes[0];
// if ((definedScheme == scheme) && (event.isSchemeDefined())) {
// continue; // skip this one, it was just defined.
// }
// previousSchemes.add(definedSchemes[0].getId());
// }
// if (!event.isSchemeDefined()) {
// previousSchemes.add(scheme.getId());
// }
// } else {
// previousSchemes = null;
// }
//
// fireCommandManagerChanged(new CommandManagerEvent(this, false, event
// .isActiveSchemeChanged(), event.isLocaleChanged(), event
// .isPlatformChanged(), false, false, schemeDefinitionsChanged,
// null, null, previousSchemes));
// }
//
// /*
// * (non-Javadoc)
// *
// * @see org.eclipse.commands.ICommandManagerListener#commandManagerChanged(org.eclipse.commands.CommandManagerEvent)
// */
// public final void commandManagerChanged(
// final org.eclipse.core.commands.CommandManagerEvent event) {
// // Figure out the set of previous category identifiers.
// final boolean categoryIdsChanged = event.isCategoryChanged();
// final Set previousCategoryIds;
// if (categoryIdsChanged) {
// previousCategoryIds = new HashSet(commandManager
// .getDefinedCategoryIds());
// final String categoryId = event.getCategoryId();
// if (event.isCategoryDefined()) {
// previousCategoryIds.remove(categoryId);
// } else {
// previousCategoryIds.add(categoryId);
// }
// } else {
// previousCategoryIds = null;
// }
//
// // Figure out the set of previous command identifiers.
// final boolean commandIdsChanged = event.isCommandChanged();
// final Set previousCommandIds;
// if (commandIdsChanged) {
// previousCommandIds = new HashSet(commandManager
// .getDefinedCommandIds());
// final String commandId = event.getCommandId();
// if (event.isCommandDefined()) {
// previousCommandIds.remove(commandId);
// } else {
// previousCommandIds.add(commandId);
// }
// } else {
// previousCommandIds = null;
// }
//
// fireCommandManagerChanged(new CommandManagerEvent(this, false, false,
// false, false, categoryIdsChanged, commandIdsChanged, false,
// previousCategoryIds, previousCommandIds, null));
// }
//
// public final void contextManagerChanged(final ContextManagerEvent event) {
// fireCommandManagerChanged(new CommandManagerEvent(this, event
// .isActiveContextsChanged(), false, false, false, false, false,
// false, null, null, null));
// }
//
// private void fireCommandManagerChanged(
// CommandManagerEvent commandManagerEvent) {
// if (commandManagerEvent == null) {
// throw new NullPointerException();
// }
// if (commandManagerListeners != null) {
// for (int i = 0; i < commandManagerListeners.size(); i++) {
// ((ICommandManagerListener) commandManagerListeners.get(i))
// .commandManagerChanged(commandManagerEvent);
// }
// }
// }
//
// public Set getActiveContextIds() {
// return contextManager.getActiveContextIds();
// }
//
// public String getActiveKeyConfigurationId() {
// final Scheme scheme = bindingManager.getActiveScheme();
// if (scheme != null) {
// return scheme.getId();
// }
//
// /*
// * TODO This is possibly a breaking change. The id should be non-null,
// * and presumably, a real scheme id.
// */
// return Util.ZERO_LENGTH_STRING;
// }
//
// public String getActiveLocale() {
// return bindingManager.getLocale();
// }
//
// public String getActivePlatform() {
// return bindingManager.getPlatform();
// }
//
// public ICategory getCategory(String categoryId) {
// // TODO Provide access to the categories.
// // return new CategoryWrapper(commandManager.getCategory(categoryId));
// return null;
// }
//
// public ICommand getCommand(String commandId) {
// final Command command = commandManager.getCommand(commandId);
// return new CommandLegacyWrapper(command, bindingManager);
// }
//
// /*
// * (non-Javadoc)
// *
// * @see org.eclipse.ui.commands.ICommandManager#getDefinedCategoryIds()
// */
// public Set getDefinedCategoryIds() {
// return commandManager.getDefinedCategoryIds();
// }
//
// public Set getDefinedCommandIds() {
// return commandManager.getDefinedCommandIds();
// }
//
// public Set getDefinedKeyConfigurationIds() {
// final Set definedIds = new HashSet();
// final Scheme[] schemes = bindingManager.getDefinedSchemes();
// for (int i = 0; i < schemes.length; i++) {
// definedIds.add(schemes[i].getId());
// }
// return definedIds;
// }
//
// public IKeyConfiguration getKeyConfiguration(String keyConfigurationId) {
// final Scheme scheme = bindingManager.getScheme(keyConfigurationId);
// return new SchemeLegacyWrapper(scheme, bindingManager);
// }
//
// public Map getPartialMatches(KeySequence keySequence) {
// // RAP [bm]:
//// try {
//// final org.eclipse.jface.bindings.keys.KeySequence sequence = org.eclipse.jface.bindings.keys.KeySequence
//// .getInstance(keySequence.toString());
//// final Map partialMatches = bindingManager
//// .getPartialMatches(sequence);
//// final Map returnValue = new HashMap();
//// final Iterator matchItr = partialMatches.entrySet().iterator();
//// while (matchItr.hasNext()) {
//// final Map.Entry entry = (Map.Entry) matchItr.next();
//// final TriggerSequence trigger = (TriggerSequence) entry
//// .getKey();
//// if (trigger instanceof org.eclipse.jface.bindings.keys.KeySequence) {
//// final org.eclipse.jface.bindings.keys.KeySequence triggerKey = (org.eclipse.jface.bindings.keys.KeySequence) trigger;
//// returnValue.put(KeySequence.getInstance(triggerKey
//// .toString()), entry.getValue());
//// }
//// }
//// return returnValue;
//// } catch (final ParseException e) {
//// return new HashMap();
//// } catch (final org.eclipse.ui.keys.ParseException e) {
//// return new HashMap();
//// }
// return new HashMap();
// // RAPEND: [bm]
// }
//
// public String getPerfectMatch(KeySequence keySequence) {
// // RAP [bm]:
//// try {
//// final org.eclipse.jface.bindings.keys.KeySequence sequence = org.eclipse.jface.bindings.keys.KeySequence
//// .getInstance(keySequence.toString());
//// final Binding binding = bindingManager.getPerfectMatch(sequence);
//// if (binding == null) {
//// return null;
//// }
////
//// return binding.getParameterizedCommand().getId();
////
//// } catch (final ParseException e) {
//// return null;
//// }
// return null;
// // RAPEND: [bm]
// }
//
// public boolean isPartialMatch(KeySequence keySequence) {
// // RAP [bm]:
//// try {
//// final org.eclipse.jface.bindings.keys.KeySequence sequence = org.eclipse.jface.bindings.keys.KeySequence
//// .getInstance(keySequence.toString());
//// return bindingManager.isPartialMatch(sequence);
//// } catch (final ParseException e) {
//// return false;
//// }
// return false;
// // RAPEND: [bm]
// }
//
// public boolean isPerfectMatch(KeySequence keySequence) {
// // RAP [bm]:
//// try {
//// final org.eclipse.jface.bindings.keys.KeySequence sequence = org.eclipse.jface.bindings.keys.KeySequence
//// .getInstance(keySequence.toString());
//// return bindingManager.isPerfectMatch(sequence);
//// } catch (final ParseException e) {
//// return false;
//// }
// return false;
// }
//
// public void removeCommandManagerListener(
// ICommandManagerListener commandManagerListener) {
// if (commandManagerListener == null) {
// throw new NullPointerException("Cannot remove a null listener"); //$NON-NLS-1$
// }
//
// if (commandManagerListeners != null) {
// commandManagerListeners.remove(commandManagerListener);
// if (commandManagerListeners.isEmpty()) {
// commandManagerListeners = null;
// this.commandManager.removeCommandManagerListener(this);
// this.bindingManager.removeBindingManagerListener(this);
// this.contextManager.removeContextManagerListener(this);
// }
// }
// }
//
// /**
// * Updates the handlers for a block of commands all at once.
// *
// * @param handlersByCommandId
// * The map of command identifier (<code>String</code>) to
// * handler (<code>IHandler</code>).
// */
// public final void setHandlersByCommandId(final Map handlersByCommandId) {
// // Wrap legacy handlers so they can be passed to the new API.
// final Iterator entryItr = handlersByCommandId.entrySet().iterator();
// while (entryItr.hasNext()) {
// final Map.Entry entry = (Map.Entry) entryItr.next();
// final Object handler = entry.getValue();
// if (handler instanceof org.eclipse.ui.commands.IHandler) {
// final String commandId = (String) entry.getKey();
// handlersByCommandId.put(commandId, new LegacyHandlerWrapper(
// (org.eclipse.ui.commands.IHandler) handler));
// }
// }
//
// commandManager.setHandlersByCommandId(handlersByCommandId);
// }
//}